#include "Ppd_funciones.h"
#include "Algoritmos.h"
#include "Estructuras.h"

/*------------- FUNCIONES PARA LISTA PISTAS -------------*/

TNodoPista *buscarProximaPista(void){
	TNodoPista *atender;
	extern char algoritmo[10];

	if(!strcmp(algoritmo,"SSTF"))
		atender=buscarProximoPorSSTF();
	if(!strcmp(algoritmo, "FSCAN"))
		atender=buscarProximoPorFSCAN();
	if(strcmp(algoritmo,"SSTF") && strcmp(algoritmo,"FSCAN")){
		atender=NULL;
		printf("\nAlgoritmo invalido: %s\n", algoritmo);
	}
	return atender;
}

TNodoPista *buscarProximoPorSSTF(void){
	int32_t flag, flag2;
	TNodoPista *aux, *ptrAnt, *ptrPos, *aux2;
	extern struct pistaSector infoCabActual;
	int32_t difeAnt=0,difePos=0;
	extern TNodoPista *listaPistas;

	aux=listaPistas;
	if (aux==NULL){
		return NULL;
	}
	else{
		if(aux->Next==NULL){
			listaPistas=NULL;
			return aux;
		}
		else{
			ptrAnt=aux;
			flag=1;
			aux2=aux;
			flag2=1;
			while((aux!=NULL)&&(aux->pista < infoCabActual.pista)&&(aux->SL!=NULL)){
				if(flag>2){
					aux2=aux2->Next;
				}
				else{
					flag++;
				}
				ptrAnt=aux;
				aux=aux->Next;
				flag2++;
			}
			ptrPos=aux;

			if(ptrPos!=NULL){
				difeAnt=infoCabActual.pista-ptrAnt->pista;
				difePos=ptrPos->pista-infoCabActual.pista;

				if(abs(difeAnt)<abs(difePos)){//Si difeAnt es menor a difePos, elegimos a ptrAnt
					if(flag==2){
						listaPistas=listaPistas->Next;
						aux=aux2;
						aux->Next=NULL;
					}
					else{
						aux2->Next=ptrPos;
						aux=ptrAnt;
						ptrAnt->Next=NULL;
						aux->Next=NULL;
					}

				}
				if(flag2==1){//Si es el primer nodo de la listaPistas
					listaPistas=aux->Next;
					aux->Next=NULL;
				}
				else{
					if(difeAnt>difePos){//Si difeAnt es mayor a difePos, elegimos a ptrPos
						ptrAnt->Next=aux->Next;
						ptrPos->Next=NULL;
						aux=ptrPos;
						aux->Next=NULL;
					}
					if(difeAnt==difePos){//Si difeAnt es igual  a difePos, elegimos por FIFO  (el primero que llego)
						if(ptrAnt->orden>ptrPos->orden){//primero llego ptrPos
							ptrAnt->Next=aux->Next;
							ptrPos->Next=NULL;
							aux=ptrPos;
						}
						else{//primero llego ptrAnt
							if (aux2->pista==ptrAnt->pista){
								listaPistas=ptrPos;
								ptrAnt->Next=NULL;
								aux=ptrAnt;
							}
							else{
								aux2->Next=ptrPos;
								ptrAnt->Next=NULL;
								aux=ptrAnt;
							}

						}
					}
				}
				return aux;
			}
			else{
				aux2->Next=NULL;
				ptrAnt->Next=NULL;
				return ptrAnt;
			}

		}
	}
}

TNodoPista *buscarProximoPorFSCAN(){
	extern struct pistaSector infoCabActual;
	extern TNodoPista *listaPistas;
	extern char movimientoCabezal;
	extern int32_t cantPistas;
	TNodoPista *auxPistas, *ant, *atender;
	int32_t primero=1;
	extern int32_t flagCambio;
	extern int32_t flagPri;

	flagCambio=0;

	auxPistas=listaPistas;

	if(flagPri==0)
		flagPri=1;
	else
		flagPri=2;
	if(auxPistas==NULL)
		return NULL;
	else{
		if(movimientoCabezal=='A'){
			while(auxPistas->Next!=NULL && auxPistas->pista<infoCabActual.pista){
				ant=auxPistas;
				auxPistas=auxPistas->Next;
				primero++;
			}
			if(primero==1){//entonces elijo el primer nodoPista de ListaPista
				if(listaPistas->pista<infoCabActual.pista){
					flagCambio=1;
				}
					atender=listaPistas;
					listaPistas=listaPistas->Next;
					atender->Next=NULL;
			}
			else{//no es el primero de la lista
				if(auxPistas->Next==NULL){//es el ultimo de la listaPistas
					if(auxPistas->pista<infoCabActual.pista){
						flagCambio=1;
						atender=auxPistas;
						ant->Next=NULL;
						atender->Next=NULL;
					}
					else{
					//	flagCambio=1;
						atender=auxPistas;
						ant->Next=NULL;
						atender->Next=NULL;
					}
					
				}
				else{//no es ni la primeraPista ni la ultima
					atender=auxPistas;
					ant->Next=auxPistas->Next;
					atender->Next=NULL;
				}
			}
			if(atender->pista==cantPistas-1){
				flagCambio=1;
			}
			
		}
		if(movimientoCabezal=='D'){
			while(auxPistas->Next!=NULL && auxPistas->Next->pista<=infoCabActual.pista){
				ant=auxPistas;
				auxPistas=auxPistas->Next;
				primero++;
			}
			if(primero==1){//entonces elijo el primer nodoPista de ListaPista
				if(listaPistas->pista>infoCabActual.pista){
					flagCambio=1;
				}
					atender=listaPistas;
					listaPistas=listaPistas->Next;
					atender->Next=NULL;
			}
			else{//no es el primero de la lista
				if(auxPistas->Next==NULL){//es el ultimo de la listaPistas
					atender=auxPistas;
					auxPistas->Next=NULL;
					ant->Next=NULL;
					atender->Next=NULL;
				}
				else{//no es ni la primeraPista ni la ultima
					atender=auxPistas;
					ant->Next=auxPistas->Next;
					atender->Next=NULL;
				}
			}
			if(atender->pista==0){
				flagCambio=1;
			}

		}

		return atender;
	}
}

TNodoPista *buscarUltimoNodoPistas(void){
	extern TNodoPista *listaPistas;
	TNodoPista *ultimo;
	
	ultimo=listaPistas;
	while(ultimo->Next!=NULL)
		ultimo=ultimo->Next;
	return ultimo;
}

TNodoPista *insertarPedidoEnPista(TNodoPedido *nuevoNodo){
	//Inserta en forma ascendente según las pistas.
	//Por pista hay una sublista, con las peticiones de los sectores de dicha pista.
	TNodoPista *aux1;
	TNodoPista *nPista;
	TNodoPedido *punt;
	extern TNodoPista *listaPistas;
	extern char algoritmo[10];
	extern int32_t ord;
	extern TNodoPista *listaPistasEncolar;

	if(!strcmp(algoritmo, "SSTF")){
		aux1=listaPistas;
		if(aux1==NULL){//Agrego el primer nodoPista
			nPista =(TNodoPista *)calloc(1,sizeof(TNodoPista));
			nPista->pista=nuevoNodo->pista;
			nPista->orden=ord; //el primero tiene orden=0
			ord++;
			nPista->SL=NULL;
			nPista->Next=NULL;
			punt=generarListaOrdenCrec(nPista->SL,nuevoNodo);
			nPista->SL=punt;
			listaPistas=nPista;
		}
		else{
			if(aux1->pista==nuevoNodo->pista){
				punt=generarListaOrdenCrec(aux1->SL,nuevoNodo);
				aux1->SL=punt;
			}
			else{
				if(nuevoNodo->pista<aux1->pista){
					nPista =(TNodoPista *)calloc(1,sizeof(TNodoPista));
					nPista->pista=nuevoNodo->pista;
					nPista->orden=ord;
					ord++;
					nPista->SL=NULL;
					nPista->Next=NULL;
					punt=generarListaOrdenCrec(nPista->SL,nuevoNodo);
					nPista->SL=punt;
					nPista->Next=listaPistas;
					listaPistas=nPista;
				}
				else{//si nuevoNodo->pista es mayor que aux1->pista
					while((aux1->Next!=NULL)&&(aux1->Next->pista<nuevoNodo->pista)&&(aux1->Next!=NULL))
						aux1=aux1->Next;
					if(aux1->Next==NULL){
						//llego al final de la lista
						nPista =(TNodoPista *)calloc(1,sizeof(TNodoPista));
						nPista->pista=nuevoNodo->pista;
						nPista->orden=ord;
						ord++;
						nPista->SL=NULL;
						nPista->Next=NULL;
						aux1->Next=nPista;
						punt=generarListaOrdenCrec(nPista->SL,nuevoNodo);
						nPista->SL=punt;
					}
					else{
						if (aux1->Next->pista==nuevoNodo->pista){
							punt=generarListaOrdenCrec(aux1->Next->SL,nuevoNodo);
							aux1->Next->SL=punt;
						}
						else{
							//no hay un nodo para esa pista
							nPista =(TNodoPista *)calloc(1,sizeof(TNodoPista));
							nPista->pista=nuevoNodo->pista;
							nPista->orden=ord;
							ord++;
							nPista->SL=NULL;
							nPista->Next=aux1->Next;
							aux1->Next=nPista;
							punt=generarListaOrdenCrec(nPista->SL,nuevoNodo);
							nPista->SL=punt;
						}
					}
				}
			}
		}
		aux1=listaPistas;
	}

	if(!strcmp(algoritmo, "FSCAN")){
		aux1=listaPistasEncolar;
		if(aux1==NULL){//Agrego el primer nodoPista
			nPista =(TNodoPista *)calloc(1,sizeof(TNodoPista));
			nPista->pista=nuevoNodo->pista;
			nPista->orden=0;
			nPista->SL=NULL;
			nPista->Next=NULL;
			//aux1=nPista;
			punt=generarListaOrdenCrec(nPista->SL,nuevoNodo);
			nPista->SL=punt;
			listaPistasEncolar=nPista;
		}
		else{
			if(aux1->pista==nuevoNodo->pista){
				punt=generarListaOrdenCrec(aux1->SL,nuevoNodo);
				aux1->SL=punt;
			}
			else{
				if(nuevoNodo->pista<aux1->pista){
					nPista =(TNodoPista *)calloc(1,sizeof(TNodoPista));
					nPista->pista=nuevoNodo->pista;
					nPista->orden=ord;
					ord++;
					nPista->SL=NULL;
					nPista->Next=NULL;
					punt=generarListaOrdenCrec(nPista->SL,nuevoNodo);
					nPista->SL=punt;
					nPista->Next=listaPistasEncolar;
					listaPistasEncolar=nPista;
				}
				else{//si nuevoNodo->pista es mayor que aux1->pista
					while((aux1->Next!=NULL)&&(aux1->Next->pista<nuevoNodo->pista))
						aux1=aux1->Next;
					if(aux1->Next==NULL){
						//llego al final de la lista
						nPista =(TNodoPista *)calloc(1,sizeof(TNodoPista));
						nPista->pista=nuevoNodo->pista;
						nPista->orden=ord;
						ord++;
						nPista->SL=NULL;
						nPista->Next=NULL;
						aux1->Next=nPista;
						punt=generarListaOrdenCrec(nPista->SL,nuevoNodo);
						nPista->SL=punt;
					}
					else{
						if (aux1->Next->pista==nuevoNodo->pista){
							punt=generarListaOrdenCrec(aux1->Next->SL,nuevoNodo);
							aux1->Next->SL=punt;
						}
						else{
							//no hay un nodo para esa pista
							nPista =(TNodoPista *)calloc(1,sizeof(TNodoPista));
							nPista->pista=nuevoNodo->pista;
							nPista->orden=ord;
							ord++;
							nPista->SL=NULL;
							nPista->Next=aux1->Next;
							aux1->Next=nPista;
							punt=generarListaOrdenCrec(nPista->SL,nuevoNodo);
							nPista->SL=punt;
						}
					}
				}
			}
		}
		aux1=listaPistasEncolar;
	}
	return aux1;
}

TNodoPedido *buscarProxSector(TNodoPista *nodoPista,pistaSector *proxSectorTRACE){
	int32_t pistaALeer,flag=0;
	struct pistaSector aux;
	extern struct pistaSector infoCabActual;
	TNodoPedido *auxNodo, *atender, *ant, *otroAux;
	extern int32_t opcionLog;

	//TNodoPedido *nodoPedido;
	pistaALeer = nodoPista->pista;
	aux.pista=infoCabActual.pista;
	aux.sector=infoCabActual.sector;

	//Cambio de pista
	if(aux.pista!=pistaALeer){
		aux.pista=pistaALeer;
	}


	//aux está ubicado en pistaALeer y en el sector correspondiente

	auxNodo=nodoPista->SL;
	ant=auxNodo;
	if(auxNodo!=NULL){
		while((auxNodo->Next!=NULL)&&(auxNodo->sector<aux.sector)){
			ant=auxNodo;
			auxNodo=auxNodo->Next;
			flag=1;
		}
		if(flag==0){//En el caso de que se atienda al primer nodo
			atender=auxNodo;
			if(auxNodo->Next==NULL){//En el caso de que sea el último pedido de la pista
				nodoPista->SL=NULL;
				if((auxNodo->tOper=='T')||(opcionLog))
					*proxSectorTRACE=buscarProxSectorParaTrace(atender->pista, atender->sector);//Devuelve el próximo sector a atender segun el algoritmo
			}
			else{
				if((auxNodo->tOper=='T')||(opcionLog)){

					otroAux=auxNodo;
					while(otroAux->Next!=NULL && otroAux->sector==otroAux->Next->sector)
						otroAux=otroAux->Next;
					if(otroAux->Next==NULL){
						proxSectorTRACE->sector=auxNodo->Next->sector;
						proxSectorTRACE->pista=auxNodo->Next->pista;
					}
					else{
						proxSectorTRACE->sector=otroAux->Next->sector;
						proxSectorTRACE->pista=otroAux->Next->pista;
					}
				}
				nodoPista->SL=auxNodo->Next;
			}
		}
		else{
			if(auxNodo->sector<aux.sector){//en el caso de que todos los sectores sean menores al sector del cabezal
				auxNodo=nodoPista->SL;
				nodoPista->SL=auxNodo->Next;

				if((auxNodo->tOper=='T')||(opcionLog)){

					if(auxNodo->sector==nodoPista->SL->sector){
						otroAux=auxNodo;
						while(otroAux->Next!=NULL && otroAux->sector==otroAux->Next->sector)
							otroAux=otroAux->Next;
						if(otroAux->Next==NULL){
							proxSectorTRACE->sector=nodoPista->SL->sector;
							proxSectorTRACE->pista=nodoPista->SL->pista;
						}
						else{
							proxSectorTRACE->sector=otroAux->Next->sector;
							proxSectorTRACE->pista=otroAux->Next->pista;
						}
					}

					else{
						proxSectorTRACE->sector=auxNodo->Next->sector;
						proxSectorTRACE->pista=auxNodo->Next->pista;
					}
				}

				auxNodo->Next=NULL;
				atender=auxNodo;
			}
			else{
				//en el caso de que auxNodo->sector >= aux.sector

				if((auxNodo->tOper=='T')||(opcionLog)){

					if(auxNodo->Next!=NULL && nodoPista->SL->Next!=NULL){
						otroAux=auxNodo;
						while(otroAux->Next!=NULL && otroAux->sector==otroAux->Next->sector)
							otroAux=otroAux->Next;
						if(otroAux->Next==NULL){
							proxSectorTRACE->pista=nodoPista->SL->pista;
							proxSectorTRACE->sector=nodoPista->SL->sector;
						}
						else{
							proxSectorTRACE->pista=otroAux->Next->pista;
							proxSectorTRACE->sector=otroAux->Next->sector;
						}
					}

					if(auxNodo->Next==NULL && nodoPista->SL->Next!=NULL){
						proxSectorTRACE->pista=nodoPista->SL->pista;
						proxSectorTRACE->sector=nodoPista->SL->sector;
					}

					if(nodoPista->SL->Next==NULL)
						*proxSectorTRACE=buscarProxSectorParaTrace(auxNodo->pista, auxNodo->sector);//Devuelve el próximo sector a atender segun el algoritmo
				}

				ant->Next=auxNodo->Next;
				auxNodo->Next=NULL;
				atender=auxNodo;
			}
		}
	}

	return atender;
}

pistaSector buscarProxSectorParaTrace(int32_t pista, int32_t sector){ // Busca el "Próximo sector" para el trace
	extern char algoritmo[10];
	pistaSector  proxSectorTRACE;

	if(!strcmp(algoritmo,"SSTF"))
		proxSectorTRACE=buscarProxSectorParaTraceSSTF( pista, sector);
	if(!strcmp(algoritmo, "FSCAN"))
		proxSectorTRACE=buscarProxSectorParaTraceFSCAN( pista, sector);
	if(strcmp(algoritmo,"SSTF") && strcmp(algoritmo,"FSCAN")){
		proxSectorTRACE.pista=-2;
		proxSectorTRACE.sector=-1;
		printf("\nAlgoritmo invalido: %s\n", algoritmo);
	}
	return proxSectorTRACE;
}

pistaSector buscarProxSectorParaTraceSSTF(int32_t pista, int32_t sector){
	extern TNodoPista *listaPistas;
	extern int32_t cantidadSectoresPorPista;
	struct pistaSector auxPS;
	TNodoPista *aux, *buscadoPi, *ptrAnt, *ptrPos;
	int32_t flag, pistaALeer, difeAnt, difePos;
	TNodoPedido *auxNodo, *ant, *buscadoPe;
	pistaSector  proxSectorTRACE;
	
	aux=listaPistas;
	if(aux==NULL || aux->SL==NULL){//en el caso de que no hayan más pedidos
		proxSectorTRACE.pista=-1;
		proxSectorTRACE.sector=-1;
		return proxSectorTRACE;
	}
	else{
		//Busco la pista que corresponde según el algoritmo
		ptrAnt=aux;
		flag=1;
		while((aux!=NULL)&&(aux->pista < pista)&&(aux->SL!=NULL)){
			ptrAnt=aux;
			aux=aux->Next;
			flag++;
		}
		ptrPos=aux;

		if(ptrPos!=NULL&&ptrPos->SL!=NULL){
			difeAnt=pista-ptrAnt->pista;
			difePos=ptrPos->pista-pista;
			
			if(abs(difeAnt)<abs(difePos)){//Si difeAnt es menor a difePos, elegimos a ptrAnt
				buscadoPi=ptrAnt;
			}
			if(flag==1)//Si es el primer nodo de la listaPistas
				buscadoPi=listaPistas;
			else{
				if(difeAnt>difePos){//Si difeAnt es mayor a difePos, elegimos a ptrPos
					buscadoPi=ptrPos;
				}
				if(difeAnt==difePos){//Si difeAnt es igual  a difePos, elegimos por FIFO  (el primero que llego)
					if(ptrAnt->orden>ptrPos->orden)//primero llego ptrPos
						buscadoPi=ptrPos;
					else//primero llego ptrAnt
						buscadoPi=ptrAnt;
				}
			}
			//return aux;
		}
		else{
			buscadoPi=ptrAnt;
			//return ptrAnt;
		}
		
		//Busco el proxSector
		pistaALeer = buscadoPi->pista;
		auxPS.pista=pista;
		auxPS.sector=sector;

		//Cambio de pista
		if(auxPS.pista!=pistaALeer){
			//auxPS.sector=auxPS.sector+((pistaALeer - auxPS.pista)*cantidadSectoresPorPista);
			auxPS.pista=pistaALeer;
		}
		//aux está ubicado en pistaALeer y en el sector correspondiente

		if(auxPS.sector==cantidadSectoresPorPista-1)
			auxPS.sector=0;
		else
			auxPS.sector=auxPS.sector+1;

		auxNodo=buscadoPi->SL;
		ant=auxNodo;
		if(auxNodo!=NULL){
			while((auxNodo->Next!=NULL)&&(auxNodo->sector<auxPS.sector)){
				ant=auxNodo;
				auxNodo=auxNodo->Next;
				flag=1;
			}
			if(auxNodo->Next==NULL){
				if(auxNodo->sector<auxPS.sector){
					proxSectorTRACE.sector=buscadoPi->SL->sector;
					proxSectorTRACE.pista=buscadoPi->SL->pista;
				}
				else{
					buscadoPe=auxNodo;
					proxSectorTRACE.sector=buscadoPe->sector;
					proxSectorTRACE.pista=buscadoPe->pista;
				}
			}
			else{
				buscadoPe=auxNodo;
				proxSectorTRACE.sector=buscadoPe->sector;
				proxSectorTRACE.pista=buscadoPe->pista;
			}

		}
		else{
			proxSectorTRACE.sector=-1;
			proxSectorTRACE.pista=-1;
		}
		return proxSectorTRACE;
			
	}
}

pistaSector buscarProxSectorParaTraceFSCAN(int32_t pista, int32_t sector){
	pistaSector auxPS;
	extern TNodoPista *listaPistas;
	extern char movimientoCabezal;
	extern int32_t cantPistas;
	TNodoPista *auxPistas, *ante, *PiBuscada;
	TNodoPedido *auxNodo, *ant, *buscadoPe;
	int32_t primero=1,pistaALeer,flag=0;
	pistaSector proxSectorTRACE;
	extern int32_t cantidadSectoresPorPista;

	auxPistas=listaPistas;

	if(auxPistas==NULL){//en el caso de que no hayan más pedidos
		proxSectorTRACE.pista=-1;
		proxSectorTRACE.sector=-1;
		return proxSectorTRACE;
	}	
	else{
		if(movimientoCabezal=='A'){
			while(auxPistas->Next!=NULL && auxPistas->pista<pista){
				ante=auxPistas;
				auxPistas=auxPistas->Next;
				primero++;
			}
			if(primero==1){//entonces elijo el primer nodoPista de ListaPista
					PiBuscada=listaPistas;
			}
			else{//no es el primero de la lista
				if(auxPistas->Next==NULL){//es el ultimo de la listaPistas
					PiBuscada=auxPistas;
					
				}
				else{//no es ni la primeraPista ni la ultima
					PiBuscada=auxPistas;
				}
			}
			
		}
		if(movimientoCabezal=='D'){
			while(auxPistas->Next!=NULL && auxPistas->Next->pista<pista){
				ante=auxPistas;
				auxPistas=auxPistas->Next;
				primero++;
			}
			if(primero==1){//entonces elijo el primer nodoPista de ListaPista
					PiBuscada=listaPistas;

			}
			else{//no es el primero de la lista
				if(auxPistas->Next==NULL){//es el ultimo de la listaPistas
					PiBuscada=auxPistas;				
				}
				else{//no es ni la primeraPista ni la ultima
					PiBuscada=auxPistas;
				}
			}
		}
		
		
		//Busco el proxSector
		pistaALeer = PiBuscada->pista;
		auxPS.pista=pista;
		auxPS.sector=sector;

		//Cambio de pista
		if(auxPS.pista!=pistaALeer){
			//auxPS.sector=auxPS.sector+((pistaALeer - auxPS.pista)*cantidadSectoresPorPista);
			auxPS.pista=pistaALeer;
		}
		//aux está ubicado en pistaALeer y en el sector correspondiente

		if(auxPS.sector==cantidadSectoresPorPista-1)
			auxPS.sector=0;
		else
			auxPS.sector=auxPS.sector+1;

		auxNodo=PiBuscada->SL;
		ant=auxNodo;
		if(auxNodo!=NULL){
			while((auxNodo->Next!=NULL)&&(auxNodo->sector<auxPS.sector)){
				ant=auxNodo;
				auxNodo=auxNodo->Next;
				flag=1;
			}
			buscadoPe=auxNodo;
			proxSectorTRACE.sector=buscadoPe->sector;
			proxSectorTRACE.pista=buscadoPe->pista;
		}
		else{
			proxSectorTRACE.sector=-1;
			proxSectorTRACE.pista=-1;
		}
	
		return proxSectorTRACE;
	}

}

/*------------- FUNCIONES PARA SUBLISTAS ----------------*/

TNodoPedido *sacarElementoDeSubLista( TNodoPedido *subLista){

	TNodoPedido *element=NULL;
	TNodoPedido *Aux=NULL;

	Aux =(TNodoPedido *) calloc(1,sizeof(TNodoPedido));
	if( subLista != NULL ){
		element = subLista;
		subLista = subLista->Next;

		Aux->pista= element->pista;
		Aux->sector= element->sector;
		Aux->tOper= element->tOper;
		Aux->sock=element->sock;
		memcpy(Aux->idDescriptor, element->idDescriptor,16);
		memcpy(Aux->datos,element->datos,512);
		free(element);

		return Aux;
	}
	else return NULL;
}

TNodoPedido *generarListaOrdenCrec(TNodoPedido *lista, TNodoPedido *element){
/*Lo vamos a usar con las sublistas*/
	TNodoPedido *p;

    if(lista==NULL){
		/*Lista Vacía, InsertaDelante*//*
    	 	aux= (TNodoPedido *) calloc(1,sizeof(TNodoPedido));
			aux->sector = element->sector;
			aux->tOper = element->tOper;
			aux->pista = element->pista;
			memcpy(aux->datos,element->datos,512);
			aux->sock=element->sock;
			memcpy(aux->idDescriptor, element->idDescriptor,16);
			aux->Next = NULL;
			lista=aux;*/
    	element->Next = NULL;
    	lista=element;

    }
    else {
    	if(element->sector<lista->sector){
			/*es menor que el primero*/
			/*aux= (TNodoPedido *) calloc(1,sizeof(TNodoPedido));
			aux->sector = element->sector;
			aux->tOper = element->tOper;
			aux->pista = element->pista;
			aux->sock=element->sock;
			memcpy(aux->idDescriptor, element->idDescriptor,16);
			memcpy(aux->datos,element->datos,512);
			aux->Next = lista;
			lista=aux;*/
    		element->Next = lista;
    		  lista=element;

		}
		else{
			p=lista;

			while((p->Next!=NULL)&&(element->sector>=p->Next->sector))
				p=p->Next;
			if(p->Next==NULL){//Inserta al final de la lista
				/*
				aux= (TNodoPedido *) calloc(1,sizeof(TNodoPedido));
				aux->sector = element->sector;
				aux->tOper = element->tOper;
				aux->pista = element->pista;
				aux->sock=element->sock;
				memcpy(aux->idDescriptor, element->idDescriptor,16);
				memcpy(aux->datos,element->datos,512);
				aux->Next = NULL;
				p->Next=aux;*/
				element->Next = NULL;
				p->Next=element;
			}
			else{
				/*aux= (TNodoPedido *) calloc(1,sizeof(TNodoPedido));
				aux->sector = element->sector;
				aux->tOper = element->tOper;
				aux->pista = element->pista;
				aux->sock=element->sock;
				memcpy(aux->idDescriptor, element->idDescriptor,16);
				memcpy(aux->datos,element->datos,512);
				aux->Next = p->Next;
				p->Next=aux;*/
				element->Next = p->Next;
				p->Next=element;
			}
		}
    }
	//free(element);
    return lista;
}

/*----------------------- PARA NodosTrace-----------------*/

TCola *CrearCola(void){
	TCola* Cola;
	Cola=(TCola *)calloc(1, sizeof(TCola));
    Cola->Head = NULL;
    Cola->Tail = NULL;
    return Cola;
}

void meterCola( TCola *nodosTRACE, TNodoPedido *element){

	if( element != NULL ){

		if( nodosTRACE->Tail != NULL ){
			nodosTRACE->Tail->Next = element;
			nodosTRACE->Tail = nodosTRACE->Tail->Next;
		}
		else{
			nodosTRACE->Head = element;
			nodosTRACE->Tail = element;
		}
	}
}

TNodoPedido *sacarElemento(TCola *nodosTRACE){

	TNodoPedido *element=NULL;

	if( nodosTRACE->Head != NULL ){
		element = nodosTRACE->Head;
		if(nodosTRACE->Head->Next!=NULL)
			nodosTRACE->Head = nodosTRACE->Head->Next;
		else{
			nodosTRACE->Head=NULL;
		}
		if( nodosTRACE->Head == NULL ){
			nodosTRACE->Tail = NULL;
		}
		element->Next=NULL;
		return element;

	}
	else return NULL;
}

/*----------------------- Para Log ----------------------*/

void enumerarPedidos(char *pedidos, TNodoPista *PistaAtender){
	extern TNodoPista *listaPistas;
	TNodoPista *auxPistas;
	TNodoPedido *auxPedido;
	int cantPedidos;
	int flag=0;

	memset(pedidos,'\0',512);
	sprintf(pedidos,"Cola de Pedidos: [");

	auxPistas=listaPistas;
	cantPedidos=0;
	if(auxPistas!=NULL){
		while(auxPistas!=NULL && auxPistas->SL!=NULL){
			if((auxPistas->pista>PistaAtender->pista && flag!=2)||(auxPistas==NULL && PistaAtender!=NULL)){
				flag=1;
				auxPedido=PistaAtender->SL;
			}
			else{
				auxPedido=auxPistas->SL;
			}
			while(auxPedido!=NULL){
				sprintf(pedidos,"%s %d:%d ",pedidos,auxPedido->pista, auxPedido->sector);
				cantPedidos++;
				auxPedido=auxPedido->Next;
			}
			if(flag==1)
				flag=2;
			else
				auxPistas=auxPistas->Next;
		}

	}
	else{
		if(PistaAtender!=NULL){
			auxPedido=PistaAtender->SL;
			while(auxPedido!=NULL){
				sprintf(pedidos,"%s %d:%d ",pedidos,auxPedido->pista, auxPedido->sector);
				cantPedidos++;
				auxPedido=auxPedido->Next;
			}
		}
	}
	sprintf(pedidos,"%s]\nTamanio: %d \n",pedidos,cantPedidos);

}
